package org.abc.fund.controller.combination; // 请确保包名正确

import jakarta.persistence.EntityNotFoundException;
import jakarta.validation.Valid;
import org.abc.fund.dto.combination.CombinationDetailDTO;
import org.abc.fund.dto.combination.CombinationProductDTO;
import org.abc.fund.dto.combination.RejectReasonDTO;
import org.abc.fund.service.combination.CombinationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 组合产品的API控制器。
 * 负责处理所有与组合产品相关的HTTP请求。
 */
@RestController
@RequestMapping("/api/combinations")
public class CombinationController {

    @Autowired
    private CombinationService combinationService;

    /**
     * 获取组合产品列表，支持按状态筛选。
     * @param status (可选) URL查询参数，例如 ?status=PENDING_APPROVAL
     */
    @GetMapping
    public ResponseEntity<List<CombinationProductDTO>> getAllCombinations(
            @RequestParam(required = false) String status) {
        List<CombinationProductDTO> products = combinationService.getAllCombinationProducts(status);
        return ResponseEntity.ok(products);
    }

    /**
     * 批准组合产品的接口。
     */
    @PostMapping("/{id}/approve")
    public ResponseEntity<String> approveCombination(@PathVariable Long id) {
        try {
//            // 在批准前，先将状态更新为 PENDING_APPROVAL
//            combinationService.submitForApproval(id);

            final Long FIXED_APPROVER_ID = 1L;
            combinationService.approveCombination(id, FIXED_APPROVER_ID);
            return ResponseEntity.ok("产品已批准。");
        } catch (EntityNotFoundException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage());
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
        }
    }

    /**
     * 驳回组合产品的接口。
     */
    @PostMapping("/{id}/reject")
    public ResponseEntity<String> rejectCombination(@PathVariable Long id, @RequestBody RejectReasonDTO dto) {
        try {
//            // 在驳回前，同样先将状态更新为 PENDING_APPROVAL
//            combinationService.submitForApproval(id);

            final Long FIXED_APPROVER_ID = 1L;
            combinationService.rejectCombination(id, dto, FIXED_APPROVER_ID);
            return ResponseEntity.ok("产品已驳回。");
        } catch (EntityNotFoundException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage());
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
        }
    }
    /**
     * GET /api/combinations/{id}
     * 获取指定ID的组合产品的详细信息。
     */
    @GetMapping("/{id}")
    public ResponseEntity<CombinationDetailDTO> getCombinationById(@PathVariable Long id) {
        CombinationDetailDTO product = combinationService.getCombinationProductById(id);
        if (product == null) {
            // 如果服务层返回null，说明未找到资源，返回404 Not Found
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(product);
    }

    /**
     * POST /api/combinations
     * 创建一个新的组合产品。
     * @Valid 注解会触发DTO中定义的校验规则。
     */
    @PostMapping
    public ResponseEntity<CombinationDetailDTO> createCombination(@Valid @RequestBody CombinationDetailDTO dto) {
        CombinationDetailDTO createdProduct = combinationService.createCombinationProduct(dto);
        // 创建成功，返回 201 Created 状态码和创建后的资源
        return new ResponseEntity<>(createdProduct, HttpStatus.CREATED);
    }

    /**
     * PUT /api/combinations/{id}
     * 更新指定ID的组合产品。
     */
    @PutMapping("/{id}")
    public ResponseEntity<?> updateCombination(@PathVariable Long id, @Valid @RequestBody CombinationDetailDTO dto) {
        try {
            CombinationDetailDTO updatedProduct = combinationService.updateCombinationProduct(id, dto);
            return ResponseEntity.ok(updatedProduct);
        } catch (EntityNotFoundException e) {
            // 如果Service层抛出未找到实体的异常，返回404
            return ResponseEntity.notFound().build();
        } catch (IllegalStateException e) {
            // 如果Service层抛出状态不合法的异常，返回400 Bad Request，并带上错误信息
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }

    /**
     * POST /api/combinations/{id}/submit
     * 提交指定ID的组合产品以供审核。
     */
    @PostMapping("/{id}/submit")
    public ResponseEntity<String> submitForApproval(@PathVariable Long id) {
        try {
            combinationService.submitForApproval(id);
            // 操作成功，返回200 OK
            return ResponseEntity.ok("提交审核成功。");
        } catch (EntityNotFoundException e) {
            return ResponseEntity.notFound().build();
        } catch (IllegalStateException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }

    /**
     * DELETE /api/combinations/{id}
     * 删除指定ID的组合产品。
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteCombination(@PathVariable Long id) {
        try {
            combinationService.deleteCombinationProduct(id);
            // 删除成功，返回 204 No Content
            return ResponseEntity.noContent().build();
        } catch (EntityNotFoundException e) {
            // 如果要删除的资源本就不存在，同样可以认为是成功的（幂等性），或者返回404。
            // 这里我们选择返回204，表示最终状态符合预期。
            return ResponseEntity.noContent().build();
        }
    }
}